home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 20 / Cream of the Crop 20 (Terry Blount) (1996).iso / os2 / sysb091a.zip / sysbench / src / diskacc2.c < prev    next >
C/C++ Source or Header  |  1995-12-31  |  5KB  |  215 lines
  1. /* diskacc2.c - direct disk access library for OS/2 2.x protected mode.
  2.  *
  3.  * Author:  Kai Uwe Rommel <rommel@ars.muc.de>
  4.  * Created: Fri Jul 08 1994
  5.  */
  6.  
  7. static char *rcsid =
  8. "$Id: diskacc2.c,v 1.2 1995/12/31 21:50:58 rommel Exp $";
  9. static char *rcsrev = "$Revision: 1.2 $";
  10.  
  11. /*
  12.  * $Log: diskacc2.c,v $
  13.  * Revision 1.2  1995/12/31 21:50:58  rommel
  14.  * added physical/logical mode parameter
  15.  *
  16.  * Revision 1.1  1994/07/08 21:34:12  rommel
  17.  * Initial revision
  18.  * 
  19.  */
  20.  
  21. #define INCL_DOSDEVICES
  22. #define INCL_DOSDEVIOCTL
  23. #define INCL_NOPM
  24. #include <os2.h>
  25. #include <string.h>
  26. #include <ctype.h>
  27.  
  28. #include "diskacc2.h"
  29.  
  30. #define PHYSICAL     0x1000
  31. #define CATEGORY(x)  (((x) & PHYSICAL) ? IOCTL_PHYSICALDISK : IOCTL_DISK)
  32. #define HANDLE(x)    ((x) & ~PHYSICAL)
  33.  
  34. #pragma pack(1)
  35.  
  36. typedef struct
  37. {
  38.   BYTE   bCommand;
  39.   USHORT usHead;
  40.   USHORT usCylinder;
  41.   USHORT usFirstSector;
  42.   USHORT cSectors;
  43.   struct
  44.   {
  45.     USHORT usSectorNumber;
  46.     USHORT usSectorSize;
  47.   }
  48.   TrackTable[64];
  49. }
  50. TRACK;
  51.  
  52. ULONG DosDevIOCtl32(PVOID pData, ULONG cbData, PVOID pParms, ULONG cbParms,
  53.             ULONG usFunction, HFILE hDevice)
  54. {
  55.   ULONG ulParmLengthInOut = cbParms, ulDataLengthInOut = cbData;
  56.   return DosDevIOCtl(HANDLE(hDevice), CATEGORY(hDevice), usFunction,
  57.              pParms, cbParms, &ulParmLengthInOut, 
  58.              pData, cbData, &ulDataLengthInOut);
  59. }
  60.  
  61. static int test_sector(int handle, int side, int track, int sector)
  62. {
  63.   char buffer[1024];
  64.   TRACK trk;
  65.  
  66.   trk.bCommand      = 0;
  67.   trk.usHead        = side;
  68.   trk.usCylinder    = track;
  69.   trk.usFirstSector = 0;
  70.   trk.cSectors      = 1;
  71.  
  72.   trk.TrackTable[0].usSectorNumber = sector;
  73.   trk.TrackTable[0].usSectorSize   = 512;
  74.  
  75.   return DosDevIOCtl32(buffer, sizeof(buffer), &trk, sizeof(trk), 
  76.                DSK_READTRACK, handle) == 0;
  77. }
  78.  
  79. int DskOpen(char *drv, int logical, int lock, 
  80.         unsigned *sides, unsigned *tracks, unsigned *sectors)
  81. {
  82.   BIOSPARAMETERBLOCK bpb;
  83.   DEVICEPARAMETERBLOCK dpb;
  84.   HFILE handle;
  85.   USHORT physical;
  86.   ULONG action;
  87.   BYTE cmd = logical;
  88.  
  89.   if (isalpha(drv[0]) && drv[1] == ':' && drv[2] == 0)
  90.   {
  91.     if (DosOpen(drv, &handle, &action, 0L, FILE_NORMAL, FILE_OPEN,
  92.         OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR |
  93.         OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE, 0L))
  94.       return -1;
  95.   }
  96.   else if (drv[0] == '$' && isdigit(drv[1]) && drv[2] == ':' && drv[3] == 0)
  97.   {
  98.     if (DosPhysicalDisk(INFO_GETIOCTLHANDLE, &physical, sizeof(physical), 
  99.             drv + 1, strlen(drv + 1) + 1))
  100.       return -1;
  101.     handle = physical | PHYSICAL;
  102.   }
  103.   else
  104.     return -1;
  105.  
  106.   if (handle & PHYSICAL)
  107.   {
  108.     if (DosDevIOCtl32(&dpb, sizeof(dpb), &cmd, sizeof(cmd), 
  109.               DSK_GETDEVICEPARAMS, handle))
  110.     {
  111.       DosPhysicalDisk(INFO_FREEIOCTLHANDLE, NULL, 0, &physical, sizeof(physical));
  112.       return -1;
  113.     }
  114.  
  115.     *sectors = dpb.cSectorsPerTrack;
  116.     *tracks  = dpb.cCylinders;
  117.     *sides   = dpb.cHeads;
  118.   }
  119.   else
  120.   {
  121.     if (DosDevIOCtl32(&bpb, sizeof(bpb), &cmd, sizeof(cmd), 
  122.               DSK_GETDEVICEPARAMS, handle))
  123.     {
  124.       DosClose(handle);
  125.       return -1;
  126.     }
  127.  
  128.     *sectors = bpb.usSectorsPerTrack;
  129.     *tracks  = bpb.cCylinders;
  130.     *sides   = bpb.cHeads;
  131.   }
  132.  
  133.  
  134.   if (lock && DosDevIOCtl32(0L, 0, &cmd, sizeof(cmd), DSK_LOCKDRIVE, handle))
  135.   {
  136.     if (handle & PHYSICAL)
  137.       DosPhysicalDisk(INFO_FREEIOCTLHANDLE, NULL, 0, &physical, sizeof(physical));
  138.     else
  139.       DosClose(handle);
  140.     return -1;
  141.   }
  142.  
  143.   if (*sectors >= 15) /* 360k floppies ... */
  144.     if (!test_sector(handle, 0, 0, 15))
  145.     {
  146.       if (*sectors == 15)
  147.         *tracks = 40;
  148.  
  149.       *sectors = 9;
  150.     }
  151.  
  152.   return handle;
  153. }
  154.  
  155. int DskClose(int handle)
  156. {
  157.   BYTE cmd = 0;
  158.   USHORT physical = handle & ~PHYSICAL;
  159.  
  160.   DosDevIOCtl32(0L, 0, &cmd, sizeof(cmd), DSK_UNLOCKDRIVE, handle);
  161.  
  162.   if (handle & PHYSICAL)
  163.     return DosPhysicalDisk(INFO_FREEIOCTLHANDLE, NULL, 0, 
  164.                &physical, sizeof(physical));
  165.   else
  166.     return DosClose(handle);
  167. }
  168.  
  169. int DskRead(int handle, unsigned side, unsigned  track,
  170.             unsigned sector, unsigned nsects, void *buf)
  171. {
  172.   TRACK trk;
  173.   unsigned cnt;
  174.  
  175.   trk.bCommand      = 0;
  176.   trk.usHead        = side;
  177.   trk.usCylinder    = track;
  178.   trk.usFirstSector = 0;
  179.   trk.cSectors      = nsects;
  180.  
  181.   for (cnt = 0; cnt < nsects; cnt++)
  182.   {
  183.     trk.TrackTable[cnt].usSectorNumber = sector + cnt;
  184.     trk.TrackTable[cnt].usSectorSize   = 512;
  185.   }
  186.  
  187.   return DosDevIOCtl32(buf, nsects * 512, &trk, sizeof(trk), 
  188.                        DSK_READTRACK, handle);
  189. }
  190.  
  191. int DskWrite(int handle, unsigned side, unsigned  track,
  192.              unsigned sector, unsigned nsects, void *buf)
  193. {
  194.   TRACK trk;
  195.   unsigned cnt;
  196.  
  197.   trk.bCommand      = 0;
  198.   trk.usHead        = side;
  199.   trk.usCylinder    = track;
  200.   trk.usFirstSector = 0;
  201.   trk.cSectors      = nsects;
  202.  
  203.   for (cnt = 0; cnt < nsects; cnt++)
  204.   {
  205.     trk.TrackTable[cnt].usSectorNumber = sector + cnt;
  206.     trk.TrackTable[cnt].usSectorSize   = 512;
  207.   }
  208.  
  209.   return DosDevIOCtl32(buf, nsects * 512, &trk, sizeof(trk), 
  210.                        DSK_WRITETRACK, handle);
  211. }
  212.  
  213.  
  214. /* end of diskacc2.c */
  215.